#include "tmrobotdef.h"

#include <IceUtil/PushDisableWarnings.h>
#include <Ice/LocalException.h>
#include <Ice/ObjectFactory.h>
#include <Ice/Outgoing.h>
#include <Ice/OutgoingAsync.h>
#include <Ice/BasicStream.h>
#include <IceUtil/Iterator.h>
#include <IceUtil/PopDisableWarnings.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 306
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 > 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 3
#       error Ice patch level mismatch!
#   endif
#endif

namespace
{

const ::std::string __Robot__Json__Load_name = "Load";

const ::std::string __Robot__Json__CallByName_name = "CallByName";

const ::std::string __Robot__Json__CallByClass_name = "CallByClass";

const ::std::string __Robot__Json__CallByContent_name = "CallByContent";

const ::std::string __Robot__Json__Stop_name = "Stop";

const ::std::string __Robot__Json__IsPlaying_name = "IsPlaying";

const ::std::string __Robot__Json__List_name = "List";

const ::std::string __Robot__Motor__SerialWrite_name = "SerialWrite";

const ::std::string __Robot__Motor__HeadEnable_name = "HeadEnable";

const ::std::string __Robot__Motor__HeadLrInit_name = "HeadLrInit";

const ::std::string __Robot__Motor__HeadUdInit_name = "HeadUdInit";

const ::std::string __Robot__Motor__HeadLrAngle_name = "HeadLrAngle";

const ::std::string __Robot__Motor__HeadUdAngle_name = "HeadUdAngle";

const ::std::string __Robot__Motor__HandLEnable_name = "HandLEnable";

const ::std::string __Robot__Motor__HandLSwingInit_name = "HandLSwingInit";

const ::std::string __Robot__Motor__HandLExpandInit_name = "HandLExpandInit";

const ::std::string __Robot__Motor__HandLSwingAngle_name = "HandLSwingAngle";

const ::std::string __Robot__Motor__HandLExpandAngle_name = "HandLExpandAngle";

const ::std::string __Robot__Motor__HandREnable_name = "HandREnable";

const ::std::string __Robot__Motor__HandRSwingInit_name = "HandRSwingInit";

const ::std::string __Robot__Motor__HandRExpandInit_name = "HandRExpandInit";

const ::std::string __Robot__Motor__HandRSwingAngle_name = "HandRSwingAngle";

const ::std::string __Robot__Motor__HandRExpandAngle_name = "HandRExpandAngle";

const ::std::string __Robot__Motor__WheelEnable_name = "WheelEnable";

const ::std::string __Robot__Motor__WheelStop_name = "WheelStop";

const ::std::string __Robot__Motor__WheelRotate_name = "WheelRotate";

const ::std::string __Robot__Motor__WheelRun_name = "WheelRun";

const ::std::string __Robot__Motor__WheelRunDiff_name = "WheelRunDiff";

const ::std::string __Robot__Motor__HeadEye_name = "HeadEye";

const ::std::string __Robot__Motor__HeadEye2_name = "HeadEye2";

const ::std::string __Robot__Motor__HeadEar_name = "HeadEar";

const ::std::string __Robot__Motor__BodyLed_name = "BodyLed";

const ::std::string __Robot__Motor__TouchSet_name = "TouchSet";

const ::std::string __Robot__Motor__SensorBatteryValue_name = "SensorBatteryValue";

const ::std::string __Robot__Motor__SensorSonicValue_name = "SensorSonicValue";

const ::std::string __Robot__Motor__SensorInfraredValue_name = "SensorInfraredValue";

const ::std::string __Robot__Motor__SetProtect_name = "SetProtect";

const ::std::string __Robot__Motor__GetProtect_name = "GetProtect";

const ::std::string __Robot__Audio__TtsPlayParams_name = "TtsPlayParams";

const ::std::string __Robot__Audio__TtsPlay_name = "TtsPlay";

const ::std::string __Robot__Audio__TtsPlayFile_name = "TtsPlayFile";

const ::std::string __Robot__Audio__TtsSetVolume_name = "TtsSetVolume";

const ::std::string __Robot__Audio__TtsStop_name = "TtsStop";

const ::std::string __Robot__Audio__TtsIsPlaying_name = "TtsIsPlaying";

const ::std::string __Robot__Audio__AsrBuildCmd_name = "AsrBuildCmd";

const ::std::string __Robot__Audio__AsrStart_name = "AsrStart";

const ::std::string __Robot__Audio__AsrStop_name = "AsrStop";

const ::std::string __Robot__Audio__MediaPlay_name = "MediaPlay";

const ::std::string __Robot__Audio__MediaSetVolume_name = "MediaSetVolume";

const ::std::string __Robot__Audio__MediaStop_name = "MediaStop";

const ::std::string __Robot__Audio__MediaIsPlaying_name = "MediaIsPlaying";

const ::std::string __Robot__ScreenEx__ShowRepeatDir_name = "ShowRepeatDir";

const ::std::string __Robot__ScreenEx__ShowPic_name = "ShowPic";

const ::std::string __Robot__ScreenEx__ShowVideo_name = "ShowVideo";

const ::std::string __Robot__ScreenEx__Clean_name = "Clean";

const ::std::string __Robot__ScreenEx__ShowVip_name = "ShowVip";

const ::std::string __Robot__ScreenEx__ShowBarrage_name = "ShowBarrage";

const ::std::string __Robot__Config__SetSystemVolume_name = "SetSystemVolume";

const ::std::string __Robot__Config__GetSystemVolume_name = "GetSystemVolume";

const ::std::string __Robot__Config__SetSystemCmd_name = "SetSystemCmd";

const ::std::string __Robot__Pub__Notify_name = "Notify";

const ::std::string __Robot__Session__List_name = "List";

const ::std::string __Robot__Live__RemoteRecvStart_name = "RemoteRecvStart";

const ::std::string __Robot__Live__RemoteRecvStop_name = "RemoteRecvStop";

}
::IceProxy::Ice::Object* ::IceProxy::Robot::upCast(::IceProxy::Robot::Json* p) { return p; }

void
::IceProxy::Robot::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Json>& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Robot::Json;
        v->__copyFrom(proxy);
    }
}

bool
IceProxy::Robot::Json::Load(const ::std::string& __p_strPath, const ::Ice::Context* __ctx)
{
    __checkTwowayOnly(__Robot__Json__Load_name);
    ::IceInternal::Outgoing __og(this, __Robot__Json__Load_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strPath);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    if(!__og.invoke())
    {
        try
        {
            __og.throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
            throw __uue;
        }
    }
    bool __ret;
    ::IceInternal::BasicStream* __is = __og.startReadParams();
    __is->read(__ret);
    __og.endReadParams();
    return __ret;
}

::Ice::AsyncResultPtr
IceProxy::Robot::Json::begin_Load(const ::std::string& __p_strPath, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    __checkAsyncTwowayOnly(__Robot__Json__Load_name);
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Json__Load_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Json__Load_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strPath);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

#ifdef ICE_CPP11

::Ice::AsyncResultPtr
IceProxy::Robot::Json::__begin_Load(const ::std::string& __p_strPath, const ::Ice::Context* __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
{
    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
    {
    public:

        Cpp11CB(const ::std::function<void (bool)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
            _response(responseFunc)
        {
            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
        }

        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
        {
            ::Robot::JsonPrx __proxy = ::Robot::JsonPrx::uncheckedCast(__result->getProxy());
            bool __ret;
            try
            {
                __ret = __proxy->end_Load(__result);
            }
            catch(const ::Ice::Exception& ex)
            {
                Cpp11FnCallbackNC::exception(__result, ex);
                return;
            }
            if(_response != nullptr)
            {
                _response(__ret);
            }
        }

    private:

        ::std::function<void (bool)> _response;
    };
    return begin_Load(__p_strPath, __ctx, new Cpp11CB(__response, __exception, __sent));
}
#endif

bool
IceProxy::Robot::Json::end_Load(const ::Ice::AsyncResultPtr& __result)
{
    ::Ice::AsyncResult::__check(__result, this, __Robot__Json__Load_name);
    bool __ret;
    if(!__result->__wait())
    {
        try
        {
            __result->__throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
        }
    }
    ::IceInternal::BasicStream* __is = __result->__startReadParams();
    __is->read(__ret);
    __result->__endReadParams();
    return __ret;
}

void
IceProxy::Robot::Json::CallByName(const ::std::string& __p_strName, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Json__CallByName_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strName);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Json::begin_CallByName(const ::std::string& __p_strName, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Json__CallByName_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Json__CallByName_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strName);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Json::end_CallByName(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Json__CallByName_name);
}

void
IceProxy::Robot::Json::CallByClass(const ::std::string& __p_strClassName, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Json__CallByClass_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strClassName);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Json::begin_CallByClass(const ::std::string& __p_strClassName, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Json__CallByClass_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Json__CallByClass_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strClassName);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Json::end_CallByClass(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Json__CallByClass_name);
}

void
IceProxy::Robot::Json::CallByContent(const ::std::string& __p_strBase64, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Json__CallByContent_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strBase64);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Json::begin_CallByContent(const ::std::string& __p_strBase64, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Json__CallByContent_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Json__CallByContent_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strBase64);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Json::end_CallByContent(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Json__CallByContent_name);
}

void
IceProxy::Robot::Json::Stop(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Json__Stop_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Json::begin_Stop(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Json__Stop_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Json__Stop_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Json::end_Stop(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Json__Stop_name);
}

bool
IceProxy::Robot::Json::IsPlaying(const ::Ice::Context* __ctx)
{
    __checkTwowayOnly(__Robot__Json__IsPlaying_name);
    ::IceInternal::Outgoing __og(this, __Robot__Json__IsPlaying_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    if(!__og.invoke())
    {
        try
        {
            __og.throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
            throw __uue;
        }
    }
    bool __ret;
    ::IceInternal::BasicStream* __is = __og.startReadParams();
    __is->read(__ret);
    __og.endReadParams();
    return __ret;
}

::Ice::AsyncResultPtr
IceProxy::Robot::Json::begin_IsPlaying(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    __checkAsyncTwowayOnly(__Robot__Json__IsPlaying_name);
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Json__IsPlaying_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Json__IsPlaying_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

#ifdef ICE_CPP11

::Ice::AsyncResultPtr
IceProxy::Robot::Json::__begin_IsPlaying(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
{
    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
    {
    public:

        Cpp11CB(const ::std::function<void (bool)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
            _response(responseFunc)
        {
            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
        }

        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
        {
            ::Robot::JsonPrx __proxy = ::Robot::JsonPrx::uncheckedCast(__result->getProxy());
            bool __ret;
            try
            {
                __ret = __proxy->end_IsPlaying(__result);
            }
            catch(const ::Ice::Exception& ex)
            {
                Cpp11FnCallbackNC::exception(__result, ex);
                return;
            }
            if(_response != nullptr)
            {
                _response(__ret);
            }
        }

    private:

        ::std::function<void (bool)> _response;
    };
    return begin_IsPlaying(__ctx, new Cpp11CB(__response, __exception, __sent));
}
#endif

bool
IceProxy::Robot::Json::end_IsPlaying(const ::Ice::AsyncResultPtr& __result)
{
    ::Ice::AsyncResult::__check(__result, this, __Robot__Json__IsPlaying_name);
    bool __ret;
    if(!__result->__wait())
    {
        try
        {
            __result->__throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
        }
    }
    ::IceInternal::BasicStream* __is = __result->__startReadParams();
    __is->read(__ret);
    __result->__endReadParams();
    return __ret;
}

void
IceProxy::Robot::Json::List(::Ice::StringSeq& __p_strList, const ::Ice::Context* __ctx)
{
    __checkTwowayOnly(__Robot__Json__List_name);
    ::IceInternal::Outgoing __og(this, __Robot__Json__List_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    if(!__og.invoke())
    {
        try
        {
            __og.throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
            throw __uue;
        }
    }
    ::IceInternal::BasicStream* __is = __og.startReadParams();
    __is->read(__p_strList);
    __og.endReadParams();
}

::Ice::AsyncResultPtr
IceProxy::Robot::Json::begin_List(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    __checkAsyncTwowayOnly(__Robot__Json__List_name);
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Json__List_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Json__List_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

#ifdef ICE_CPP11

::Ice::AsyncResultPtr
IceProxy::Robot::Json::__begin_List(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::StringSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
{
    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
    {
    public:

        Cpp11CB(const ::std::function<void (const ::Ice::StringSeq&)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
            _response(responseFunc)
        {
            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
        }

        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
        {
            ::Robot::JsonPrx __proxy = ::Robot::JsonPrx::uncheckedCast(__result->getProxy());
            ::Ice::StringSeq __p_strList;
            try
            {
                __proxy->end_List(__p_strList, __result);
            }
            catch(const ::Ice::Exception& ex)
            {
                Cpp11FnCallbackNC::exception(__result, ex);
                return;
            }
            if(_response != nullptr)
            {
                _response(__p_strList);
            }
        }

    private:

        ::std::function<void (const ::Ice::StringSeq&)> _response;
    };
    return begin_List(__ctx, new Cpp11CB(__response, __exception, __sent));
}
#endif

void
IceProxy::Robot::Json::end_List(::Ice::StringSeq& __p_strList, const ::Ice::AsyncResultPtr& __result)
{
    ::Ice::AsyncResult::__check(__result, this, __Robot__Json__List_name);
    if(!__result->__wait())
    {
        try
        {
            __result->__throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
        }
    }
    ::IceInternal::BasicStream* __is = __result->__startReadParams();
    __is->read(__p_strList);
    __result->__endReadParams();
}

const ::std::string&
IceProxy::Robot::Json::ice_staticId()
{
    return ::Robot::Json::ice_staticId();
}

::IceProxy::Ice::Object*
IceProxy::Robot::Json::__newInstance() const
{
    return new Json;
}
::IceProxy::Ice::Object* ::IceProxy::Robot::upCast(::IceProxy::Robot::Motor* p) { return p; }

void
::IceProxy::Robot::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Motor>& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Robot::Motor;
        v->__copyFrom(proxy);
    }
}

void
IceProxy::Robot::Motor::SerialWrite(const ::Ice::ByteSeq& __p_bHexData, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__SerialWrite_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bHexData);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_SerialWrite(const ::Ice::ByteSeq& __p_bHexData, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__SerialWrite_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__SerialWrite_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bHexData);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_SerialWrite(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__SerialWrite_name);
}

void
IceProxy::Robot::Motor::HeadEnable(bool __p_bLR, bool __p_bUD, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HeadEnable_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bLR);
        __os->write(__p_bUD);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HeadEnable(bool __p_bLR, bool __p_bUD, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HeadEnable_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HeadEnable_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bLR);
        __os->write(__p_bUD);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HeadEnable(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HeadEnable_name);
}

void
IceProxy::Robot::Motor::HeadLrInit(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HeadLrInit_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HeadLrInit(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HeadLrInit_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HeadLrInit_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HeadLrInit(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HeadLrInit_name);
}

void
IceProxy::Robot::Motor::HeadUdInit(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HeadUdInit_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HeadUdInit(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HeadUdInit_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HeadUdInit_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HeadUdInit(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HeadUdInit_name);
}

void
IceProxy::Robot::Motor::HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HeadLrAngle_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HeadLrAngle_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HeadLrAngle_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HeadLrAngle(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HeadLrAngle_name);
}

void
IceProxy::Robot::Motor::HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HeadUdAngle_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HeadUdAngle_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HeadUdAngle_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HeadUdAngle(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HeadUdAngle_name);
}

void
IceProxy::Robot::Motor::HandLEnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HandLEnable_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bSwing);
        __os->write(__p_bExpand);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HandLEnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HandLEnable_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HandLEnable_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bSwing);
        __os->write(__p_bExpand);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HandLEnable(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HandLEnable_name);
}

void
IceProxy::Robot::Motor::HandLSwingInit(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HandLSwingInit_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HandLSwingInit(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HandLSwingInit_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HandLSwingInit_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HandLSwingInit(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HandLSwingInit_name);
}

void
IceProxy::Robot::Motor::HandLExpandInit(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HandLExpandInit_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HandLExpandInit(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HandLExpandInit_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HandLExpandInit_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HandLExpandInit(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HandLExpandInit_name);
}

void
IceProxy::Robot::Motor::HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HandLSwingAngle_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HandLSwingAngle_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HandLSwingAngle_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HandLSwingAngle(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HandLSwingAngle_name);
}

void
IceProxy::Robot::Motor::HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HandLExpandAngle_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HandLExpandAngle_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HandLExpandAngle_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HandLExpandAngle(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HandLExpandAngle_name);
}

void
IceProxy::Robot::Motor::HandREnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HandREnable_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bSwing);
        __os->write(__p_bExpand);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HandREnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HandREnable_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HandREnable_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bSwing);
        __os->write(__p_bExpand);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HandREnable(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HandREnable_name);
}

void
IceProxy::Robot::Motor::HandRSwingInit(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HandRSwingInit_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HandRSwingInit(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HandRSwingInit_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HandRSwingInit_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HandRSwingInit(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HandRSwingInit_name);
}

void
IceProxy::Robot::Motor::HandRExpandInit(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HandRExpandInit_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HandRExpandInit(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HandRExpandInit_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HandRExpandInit_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HandRExpandInit(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HandRExpandInit_name);
}

void
IceProxy::Robot::Motor::HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HandRSwingAngle_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HandRSwingAngle_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HandRSwingAngle_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HandRSwingAngle(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HandRSwingAngle_name);
}

void
IceProxy::Robot::Motor::HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HandRExpandAngle_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HandRExpandAngle_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HandRExpandAngle_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HandRExpandAngle(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HandRExpandAngle_name);
}

void
IceProxy::Robot::Motor::WheelEnable(bool __p_bEnable, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__WheelEnable_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bEnable);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_WheelEnable(bool __p_bEnable, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__WheelEnable_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__WheelEnable_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bEnable);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_WheelEnable(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__WheelEnable_name);
}

void
IceProxy::Robot::Motor::WheelStop(bool __p_bSlow, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__WheelStop_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bSlow);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_WheelStop(bool __p_bSlow, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__WheelStop_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__WheelStop_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bSlow);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_WheelStop(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__WheelStop_name);
}

void
IceProxy::Robot::Motor::WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__WheelRotate_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__WheelRotate_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__WheelRotate_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nAngle);
        __os->write(__p_nSpeed);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_WheelRotate(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__WheelRotate_name);
}

void
IceProxy::Robot::Motor::WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__WheelRun_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDistance);
        __os->write(__p_nSpeed);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__WheelRun_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__WheelRun_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDistance);
        __os->write(__p_nSpeed);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_WheelRun(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__WheelRun_name);
}

void
IceProxy::Robot::Motor::WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__WheelRunDiff_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bLeftUP);
        __os->write(__p_nLeftSpeed);
        __os->write(__p_bRight);
        __os->write(__p_nRightSpeed);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__WheelRunDiff_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__WheelRunDiff_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bLeftUP);
        __os->write(__p_nLeftSpeed);
        __os->write(__p_bRight);
        __os->write(__p_nRightSpeed);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_WheelRunDiff(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__WheelRunDiff_name);
}

void
IceProxy::Robot::Motor::HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HeadEye_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nIndexF);
        __os->write(__p_nIndexB);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HeadEye_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HeadEye_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nIndexF);
        __os->write(__p_nIndexB);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HeadEye(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HeadEye_name);
}

void
IceProxy::Robot::Motor::HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HeadEye2_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_bR);
        __os->write(__p_bG);
        __os->write(__p_bB);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HeadEye2_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HeadEye2_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_bR);
        __os->write(__p_bG);
        __os->write(__p_bB);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HeadEye2(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HeadEye2_name);
}

void
IceProxy::Robot::Motor::HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__HeadEar_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_bR);
        __os->write(__p_bG);
        __os->write(__p_bB);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__HeadEar_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__HeadEar_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_bR);
        __os->write(__p_bG);
        __os->write(__p_bB);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_HeadEar(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__HeadEar_name);
}

void
IceProxy::Robot::Motor::BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__BodyLed_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_bR);
        __os->write(__p_bG);
        __os->write(__p_bB);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__BodyLed_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__BodyLed_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_bR);
        __os->write(__p_bG);
        __os->write(__p_bB);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_BodyLed(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__BodyLed_name);
}

void
IceProxy::Robot::Motor::TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__TouchSet_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bFlash);
        __os->write(__p_nColor);
        __os->write(__p_nDelay);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__TouchSet_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__TouchSet_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bFlash);
        __os->write(__p_nColor);
        __os->write(__p_nDelay);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_TouchSet(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__TouchSet_name);
}

void
IceProxy::Robot::Motor::SensorBatteryValue(::Ice::IntSeq& __p_nValList, const ::Ice::Context* __ctx)
{
    __checkTwowayOnly(__Robot__Motor__SensorBatteryValue_name);
    ::IceInternal::Outgoing __og(this, __Robot__Motor__SensorBatteryValue_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    if(!__og.invoke())
    {
        try
        {
            __og.throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
            throw __uue;
        }
    }
    ::IceInternal::BasicStream* __is = __og.startReadParams();
    __is->read(__p_nValList);
    __og.endReadParams();
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_SensorBatteryValue(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    __checkAsyncTwowayOnly(__Robot__Motor__SensorBatteryValue_name);
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__SensorBatteryValue_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__SensorBatteryValue_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

#ifdef ICE_CPP11

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::__begin_SensorBatteryValue(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::IntSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
{
    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
    {
    public:

        Cpp11CB(const ::std::function<void (const ::Ice::IntSeq&)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
            _response(responseFunc)
        {
            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
        }

        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
        {
            ::Robot::MotorPrx __proxy = ::Robot::MotorPrx::uncheckedCast(__result->getProxy());
            ::Ice::IntSeq __p_nValList;
            try
            {
                __proxy->end_SensorBatteryValue(__p_nValList, __result);
            }
            catch(const ::Ice::Exception& ex)
            {
                Cpp11FnCallbackNC::exception(__result, ex);
                return;
            }
            if(_response != nullptr)
            {
                _response(__p_nValList);
            }
        }

    private:

        ::std::function<void (const ::Ice::IntSeq&)> _response;
    };
    return begin_SensorBatteryValue(__ctx, new Cpp11CB(__response, __exception, __sent));
}
#endif

void
IceProxy::Robot::Motor::end_SensorBatteryValue(::Ice::IntSeq& __p_nValList, const ::Ice::AsyncResultPtr& __result)
{
    ::Ice::AsyncResult::__check(__result, this, __Robot__Motor__SensorBatteryValue_name);
    if(!__result->__wait())
    {
        try
        {
            __result->__throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
        }
    }
    ::IceInternal::BasicStream* __is = __result->__startReadParams();
    __is->read(__p_nValList);
    __result->__endReadParams();
}

void
IceProxy::Robot::Motor::SensorSonicValue(::Ice::IntSeq& __p_nValList, const ::Ice::Context* __ctx)
{
    __checkTwowayOnly(__Robot__Motor__SensorSonicValue_name);
    ::IceInternal::Outgoing __og(this, __Robot__Motor__SensorSonicValue_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    if(!__og.invoke())
    {
        try
        {
            __og.throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
            throw __uue;
        }
    }
    ::IceInternal::BasicStream* __is = __og.startReadParams();
    __is->read(__p_nValList);
    __og.endReadParams();
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_SensorSonicValue(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    __checkAsyncTwowayOnly(__Robot__Motor__SensorSonicValue_name);
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__SensorSonicValue_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__SensorSonicValue_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

#ifdef ICE_CPP11

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::__begin_SensorSonicValue(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::IntSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
{
    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
    {
    public:

        Cpp11CB(const ::std::function<void (const ::Ice::IntSeq&)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
            _response(responseFunc)
        {
            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
        }

        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
        {
            ::Robot::MotorPrx __proxy = ::Robot::MotorPrx::uncheckedCast(__result->getProxy());
            ::Ice::IntSeq __p_nValList;
            try
            {
                __proxy->end_SensorSonicValue(__p_nValList, __result);
            }
            catch(const ::Ice::Exception& ex)
            {
                Cpp11FnCallbackNC::exception(__result, ex);
                return;
            }
            if(_response != nullptr)
            {
                _response(__p_nValList);
            }
        }

    private:

        ::std::function<void (const ::Ice::IntSeq&)> _response;
    };
    return begin_SensorSonicValue(__ctx, new Cpp11CB(__response, __exception, __sent));
}
#endif

void
IceProxy::Robot::Motor::end_SensorSonicValue(::Ice::IntSeq& __p_nValList, const ::Ice::AsyncResultPtr& __result)
{
    ::Ice::AsyncResult::__check(__result, this, __Robot__Motor__SensorSonicValue_name);
    if(!__result->__wait())
    {
        try
        {
            __result->__throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
        }
    }
    ::IceInternal::BasicStream* __is = __result->__startReadParams();
    __is->read(__p_nValList);
    __result->__endReadParams();
}

void
IceProxy::Robot::Motor::SensorInfraredValue(::Ice::IntSeq& __p_nValList, const ::Ice::Context* __ctx)
{
    __checkTwowayOnly(__Robot__Motor__SensorInfraredValue_name);
    ::IceInternal::Outgoing __og(this, __Robot__Motor__SensorInfraredValue_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    if(!__og.invoke())
    {
        try
        {
            __og.throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
            throw __uue;
        }
    }
    ::IceInternal::BasicStream* __is = __og.startReadParams();
    __is->read(__p_nValList);
    __og.endReadParams();
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_SensorInfraredValue(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    __checkAsyncTwowayOnly(__Robot__Motor__SensorInfraredValue_name);
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__SensorInfraredValue_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__SensorInfraredValue_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

#ifdef ICE_CPP11

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::__begin_SensorInfraredValue(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::IntSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
{
    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
    {
    public:

        Cpp11CB(const ::std::function<void (const ::Ice::IntSeq&)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
            _response(responseFunc)
        {
            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
        }

        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
        {
            ::Robot::MotorPrx __proxy = ::Robot::MotorPrx::uncheckedCast(__result->getProxy());
            ::Ice::IntSeq __p_nValList;
            try
            {
                __proxy->end_SensorInfraredValue(__p_nValList, __result);
            }
            catch(const ::Ice::Exception& ex)
            {
                Cpp11FnCallbackNC::exception(__result, ex);
                return;
            }
            if(_response != nullptr)
            {
                _response(__p_nValList);
            }
        }

    private:

        ::std::function<void (const ::Ice::IntSeq&)> _response;
    };
    return begin_SensorInfraredValue(__ctx, new Cpp11CB(__response, __exception, __sent));
}
#endif

void
IceProxy::Robot::Motor::end_SensorInfraredValue(::Ice::IntSeq& __p_nValList, const ::Ice::AsyncResultPtr& __result)
{
    ::Ice::AsyncResult::__check(__result, this, __Robot__Motor__SensorInfraredValue_name);
    if(!__result->__wait())
    {
        try
        {
            __result->__throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
        }
    }
    ::IceInternal::BasicStream* __is = __result->__startReadParams();
    __is->read(__p_nValList);
    __result->__endReadParams();
}

void
IceProxy::Robot::Motor::SetProtect(bool __p_bOpen, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Motor__SetProtect_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bOpen);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_SetProtect(bool __p_bOpen, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__SetProtect_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__SetProtect_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_bOpen);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Motor::end_SetProtect(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Motor__SetProtect_name);
}

bool
IceProxy::Robot::Motor::GetProtect(const ::Ice::Context* __ctx)
{
    __checkTwowayOnly(__Robot__Motor__GetProtect_name);
    ::IceInternal::Outgoing __og(this, __Robot__Motor__GetProtect_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    if(!__og.invoke())
    {
        try
        {
            __og.throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
            throw __uue;
        }
    }
    bool __ret;
    ::IceInternal::BasicStream* __is = __og.startReadParams();
    __is->read(__ret);
    __og.endReadParams();
    return __ret;
}

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::begin_GetProtect(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    __checkAsyncTwowayOnly(__Robot__Motor__GetProtect_name);
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Motor__GetProtect_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Motor__GetProtect_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

#ifdef ICE_CPP11

::Ice::AsyncResultPtr
IceProxy::Robot::Motor::__begin_GetProtect(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
{
    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
    {
    public:

        Cpp11CB(const ::std::function<void (bool)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
            _response(responseFunc)
        {
            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
        }

        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
        {
            ::Robot::MotorPrx __proxy = ::Robot::MotorPrx::uncheckedCast(__result->getProxy());
            bool __ret;
            try
            {
                __ret = __proxy->end_GetProtect(__result);
            }
            catch(const ::Ice::Exception& ex)
            {
                Cpp11FnCallbackNC::exception(__result, ex);
                return;
            }
            if(_response != nullptr)
            {
                _response(__ret);
            }
        }

    private:

        ::std::function<void (bool)> _response;
    };
    return begin_GetProtect(__ctx, new Cpp11CB(__response, __exception, __sent));
}
#endif

bool
IceProxy::Robot::Motor::end_GetProtect(const ::Ice::AsyncResultPtr& __result)
{
    ::Ice::AsyncResult::__check(__result, this, __Robot__Motor__GetProtect_name);
    bool __ret;
    if(!__result->__wait())
    {
        try
        {
            __result->__throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
        }
    }
    ::IceInternal::BasicStream* __is = __result->__startReadParams();
    __is->read(__ret);
    __result->__endReadParams();
    return __ret;
}

const ::std::string&
IceProxy::Robot::Motor::ice_staticId()
{
    return ::Robot::Motor::ice_staticId();
}

::IceProxy::Ice::Object*
IceProxy::Robot::Motor::__newInstance() const
{
    return new Motor;
}
::IceProxy::Ice::Object* ::IceProxy::Robot::upCast(::IceProxy::Robot::Audio* p) { return p; }

void
::IceProxy::Robot::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Audio>& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Robot::Audio;
        v->__copyFrom(proxy);
    }
}

void
IceProxy::Robot::Audio::TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Audio__TtsPlayParams_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strTxt);
        __os->write(__p_strSpeaker);
        __os->write(__p_nSpeed);
        __os->write(__p_nPitch);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__TtsPlayParams_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__TtsPlayParams_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strTxt);
        __os->write(__p_strSpeaker);
        __os->write(__p_nSpeed);
        __os->write(__p_nPitch);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Audio::end_TtsPlayParams(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Audio__TtsPlayParams_name);
}

void
IceProxy::Robot::Audio::TtsPlay(const ::std::string& __p_strTxt, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Audio__TtsPlay_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strTxt);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_TtsPlay(const ::std::string& __p_strTxt, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__TtsPlay_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__TtsPlay_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strTxt);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Audio::end_TtsPlay(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Audio__TtsPlay_name);
}

void
IceProxy::Robot::Audio::TtsPlayFile(const ::std::string& __p_strPath, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Audio__TtsPlayFile_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strPath);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_TtsPlayFile(const ::std::string& __p_strPath, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__TtsPlayFile_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__TtsPlayFile_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strPath);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Audio::end_TtsPlayFile(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Audio__TtsPlayFile_name);
}

void
IceProxy::Robot::Audio::TtsSetVolume(::Ice::Int __p_nVal, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Audio__TtsSetVolume_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nVal);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_TtsSetVolume(::Ice::Int __p_nVal, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__TtsSetVolume_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__TtsSetVolume_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nVal);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Audio::end_TtsSetVolume(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Audio__TtsSetVolume_name);
}

void
IceProxy::Robot::Audio::TtsStop(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Audio__TtsStop_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_TtsStop(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__TtsStop_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__TtsStop_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Audio::end_TtsStop(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Audio__TtsStop_name);
}

bool
IceProxy::Robot::Audio::TtsIsPlaying(const ::Ice::Context* __ctx)
{
    __checkTwowayOnly(__Robot__Audio__TtsIsPlaying_name);
    ::IceInternal::Outgoing __og(this, __Robot__Audio__TtsIsPlaying_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    if(!__og.invoke())
    {
        try
        {
            __og.throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
            throw __uue;
        }
    }
    bool __ret;
    ::IceInternal::BasicStream* __is = __og.startReadParams();
    __is->read(__ret);
    __og.endReadParams();
    return __ret;
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_TtsIsPlaying(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    __checkAsyncTwowayOnly(__Robot__Audio__TtsIsPlaying_name);
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__TtsIsPlaying_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__TtsIsPlaying_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

#ifdef ICE_CPP11

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::__begin_TtsIsPlaying(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
{
    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
    {
    public:

        Cpp11CB(const ::std::function<void (bool)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
            _response(responseFunc)
        {
            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
        }

        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
        {
            ::Robot::AudioPrx __proxy = ::Robot::AudioPrx::uncheckedCast(__result->getProxy());
            bool __ret;
            try
            {
                __ret = __proxy->end_TtsIsPlaying(__result);
            }
            catch(const ::Ice::Exception& ex)
            {
                Cpp11FnCallbackNC::exception(__result, ex);
                return;
            }
            if(_response != nullptr)
            {
                _response(__ret);
            }
        }

    private:

        ::std::function<void (bool)> _response;
    };
    return begin_TtsIsPlaying(__ctx, new Cpp11CB(__response, __exception, __sent));
}
#endif

bool
IceProxy::Robot::Audio::end_TtsIsPlaying(const ::Ice::AsyncResultPtr& __result)
{
    ::Ice::AsyncResult::__check(__result, this, __Robot__Audio__TtsIsPlaying_name);
    bool __ret;
    if(!__result->__wait())
    {
        try
        {
            __result->__throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
        }
    }
    ::IceInternal::BasicStream* __is = __result->__startReadParams();
    __is->read(__ret);
    __result->__endReadParams();
    return __ret;
}

void
IceProxy::Robot::Audio::AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Audio__AsrBuildCmd_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strCmdList);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__AsrBuildCmd_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__AsrBuildCmd_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strCmdList);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Audio::end_AsrBuildCmd(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Audio__AsrBuildCmd_name);
}

void
IceProxy::Robot::Audio::AsrStart(::Ice::Int __p_nMaxDelayMs, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Audio__AsrStart_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nMaxDelayMs);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_AsrStart(::Ice::Int __p_nMaxDelayMs, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__AsrStart_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__AsrStart_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nMaxDelayMs);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Audio::end_AsrStart(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Audio__AsrStart_name);
}

void
IceProxy::Robot::Audio::AsrStop(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Audio__AsrStop_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_AsrStop(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__AsrStop_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__AsrStop_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Audio::end_AsrStop(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Audio__AsrStop_name);
}

void
IceProxy::Robot::Audio::MediaPlay(const ::std::string& __p_strPath, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Audio__MediaPlay_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strPath);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_MediaPlay(const ::std::string& __p_strPath, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__MediaPlay_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__MediaPlay_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strPath);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Audio::end_MediaPlay(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Audio__MediaPlay_name);
}

void
IceProxy::Robot::Audio::MediaSetVolume(::Ice::Int __p_nVal, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Audio__MediaSetVolume_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nVal);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_MediaSetVolume(::Ice::Int __p_nVal, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__MediaSetVolume_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__MediaSetVolume_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nVal);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Audio::end_MediaSetVolume(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Audio__MediaSetVolume_name);
}

void
IceProxy::Robot::Audio::MediaStop(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Audio__MediaStop_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_MediaStop(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__MediaStop_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__MediaStop_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Audio::end_MediaStop(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Audio__MediaStop_name);
}

bool
IceProxy::Robot::Audio::MediaIsPlaying(const ::Ice::Context* __ctx)
{
    __checkTwowayOnly(__Robot__Audio__MediaIsPlaying_name);
    ::IceInternal::Outgoing __og(this, __Robot__Audio__MediaIsPlaying_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    if(!__og.invoke())
    {
        try
        {
            __og.throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
            throw __uue;
        }
    }
    bool __ret;
    ::IceInternal::BasicStream* __is = __og.startReadParams();
    __is->read(__ret);
    __og.endReadParams();
    return __ret;
}

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::begin_MediaIsPlaying(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    __checkAsyncTwowayOnly(__Robot__Audio__MediaIsPlaying_name);
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Audio__MediaIsPlaying_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Audio__MediaIsPlaying_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

#ifdef ICE_CPP11

::Ice::AsyncResultPtr
IceProxy::Robot::Audio::__begin_MediaIsPlaying(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
{
    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
    {
    public:

        Cpp11CB(const ::std::function<void (bool)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
            _response(responseFunc)
        {
            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
        }

        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
        {
            ::Robot::AudioPrx __proxy = ::Robot::AudioPrx::uncheckedCast(__result->getProxy());
            bool __ret;
            try
            {
                __ret = __proxy->end_MediaIsPlaying(__result);
            }
            catch(const ::Ice::Exception& ex)
            {
                Cpp11FnCallbackNC::exception(__result, ex);
                return;
            }
            if(_response != nullptr)
            {
                _response(__ret);
            }
        }

    private:

        ::std::function<void (bool)> _response;
    };
    return begin_MediaIsPlaying(__ctx, new Cpp11CB(__response, __exception, __sent));
}
#endif

bool
IceProxy::Robot::Audio::end_MediaIsPlaying(const ::Ice::AsyncResultPtr& __result)
{
    ::Ice::AsyncResult::__check(__result, this, __Robot__Audio__MediaIsPlaying_name);
    bool __ret;
    if(!__result->__wait())
    {
        try
        {
            __result->__throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
        }
    }
    ::IceInternal::BasicStream* __is = __result->__startReadParams();
    __is->read(__ret);
    __result->__endReadParams();
    return __ret;
}

const ::std::string&
IceProxy::Robot::Audio::ice_staticId()
{
    return ::Robot::Audio::ice_staticId();
}

::IceProxy::Ice::Object*
IceProxy::Robot::Audio::__newInstance() const
{
    return new Audio;
}
::IceProxy::Ice::Object* ::IceProxy::Robot::upCast(::IceProxy::Robot::ScreenEx* p) { return p; }

void
::IceProxy::Robot::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::Robot::ScreenEx>& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Robot::ScreenEx;
        v->__copyFrom(proxy);
    }
}

void
IceProxy::Robot::ScreenEx::ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__ScreenEx__ShowRepeatDir_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_strDir);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::ScreenEx::begin_ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__ScreenEx__ShowRepeatDir_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__ScreenEx__ShowRepeatDir_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_strDir);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::ScreenEx::end_ShowRepeatDir(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__ScreenEx__ShowRepeatDir_name);
}

void
IceProxy::Robot::ScreenEx::ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__ScreenEx__ShowPic_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_strPath);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::ScreenEx::begin_ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__ScreenEx__ShowPic_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__ScreenEx__ShowPic_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_strPath);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::ScreenEx::end_ShowPic(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__ScreenEx__ShowPic_name);
}

void
IceProxy::Robot::ScreenEx::ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__ScreenEx__ShowVideo_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_strPath);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::ScreenEx::begin_ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__ScreenEx__ShowVideo_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__ScreenEx__ShowVideo_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_strPath);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::ScreenEx::end_ShowVideo(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__ScreenEx__ShowVideo_name);
}

void
IceProxy::Robot::ScreenEx::Clean(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__ScreenEx__Clean_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::ScreenEx::begin_Clean(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__ScreenEx__Clean_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__ScreenEx__Clean_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::ScreenEx::end_Clean(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__ScreenEx__Clean_name);
}

void
IceProxy::Robot::ScreenEx::ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__ScreenEx__ShowVip_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strName);
        __os->write(__p_strImg);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::ScreenEx::begin_ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__ScreenEx__ShowVip_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__ScreenEx__ShowVip_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strName);
        __os->write(__p_strImg);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::ScreenEx::end_ShowVip(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__ScreenEx__ShowVip_name);
}

void
IceProxy::Robot::ScreenEx::ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__ScreenEx__ShowBarrage_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_strTxt);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::ScreenEx::begin_ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__ScreenEx__ShowBarrage_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__ScreenEx__ShowBarrage_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nDelay);
        __os->write(__p_strTxt);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::ScreenEx::end_ShowBarrage(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__ScreenEx__ShowBarrage_name);
}

const ::std::string&
IceProxy::Robot::ScreenEx::ice_staticId()
{
    return ::Robot::ScreenEx::ice_staticId();
}

::IceProxy::Ice::Object*
IceProxy::Robot::ScreenEx::__newInstance() const
{
    return new ScreenEx;
}
::IceProxy::Ice::Object* ::IceProxy::Robot::upCast(::IceProxy::Robot::Config* p) { return p; }

void
::IceProxy::Robot::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Config>& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Robot::Config;
        v->__copyFrom(proxy);
    }
}

void
IceProxy::Robot::Config::SetSystemVolume(::Ice::Int __p_nVal, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Config__SetSystemVolume_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nVal);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Config::begin_SetSystemVolume(::Ice::Int __p_nVal, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Config__SetSystemVolume_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Config__SetSystemVolume_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_nVal);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Config::end_SetSystemVolume(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Config__SetSystemVolume_name);
}

::Ice::Int
IceProxy::Robot::Config::GetSystemVolume(const ::Ice::Context* __ctx)
{
    __checkTwowayOnly(__Robot__Config__GetSystemVolume_name);
    ::IceInternal::Outgoing __og(this, __Robot__Config__GetSystemVolume_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    if(!__og.invoke())
    {
        try
        {
            __og.throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
            throw __uue;
        }
    }
    ::Ice::Int __ret;
    ::IceInternal::BasicStream* __is = __og.startReadParams();
    __is->read(__ret);
    __og.endReadParams();
    return __ret;
}

::Ice::AsyncResultPtr
IceProxy::Robot::Config::begin_GetSystemVolume(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    __checkAsyncTwowayOnly(__Robot__Config__GetSystemVolume_name);
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Config__GetSystemVolume_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Config__GetSystemVolume_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

#ifdef ICE_CPP11

::Ice::AsyncResultPtr
IceProxy::Robot::Config::__begin_GetSystemVolume(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (::Ice::Int)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
{
    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
    {
    public:

        Cpp11CB(const ::std::function<void (::Ice::Int)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
            _response(responseFunc)
        {
            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
        }

        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
        {
            ::Robot::ConfigPrx __proxy = ::Robot::ConfigPrx::uncheckedCast(__result->getProxy());
            ::Ice::Int __ret;
            try
            {
                __ret = __proxy->end_GetSystemVolume(__result);
            }
            catch(const ::Ice::Exception& ex)
            {
                Cpp11FnCallbackNC::exception(__result, ex);
                return;
            }
            if(_response != nullptr)
            {
                _response(__ret);
            }
        }

    private:

        ::std::function<void (::Ice::Int)> _response;
    };
    return begin_GetSystemVolume(__ctx, new Cpp11CB(__response, __exception, __sent));
}
#endif

::Ice::Int
IceProxy::Robot::Config::end_GetSystemVolume(const ::Ice::AsyncResultPtr& __result)
{
    ::Ice::AsyncResult::__check(__result, this, __Robot__Config__GetSystemVolume_name);
    ::Ice::Int __ret;
    if(!__result->__wait())
    {
        try
        {
            __result->__throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
        }
    }
    ::IceInternal::BasicStream* __is = __result->__startReadParams();
    __is->read(__ret);
    __result->__endReadParams();
    return __ret;
}

void
IceProxy::Robot::Config::SetSystemCmd(const ::std::string& __p_strCmd, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Config__SetSystemCmd_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strCmd);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Config::begin_SetSystemCmd(const ::std::string& __p_strCmd, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Config__SetSystemCmd_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Config__SetSystemCmd_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strCmd);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Config::end_SetSystemCmd(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Config__SetSystemCmd_name);
}

const ::std::string&
IceProxy::Robot::Config::ice_staticId()
{
    return ::Robot::Config::ice_staticId();
}

::IceProxy::Ice::Object*
IceProxy::Robot::Config::__newInstance() const
{
    return new Config;
}
::IceProxy::Ice::Object* ::IceProxy::Robot::upCast(::IceProxy::Robot::Pub* p) { return p; }

void
::IceProxy::Robot::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Pub>& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Robot::Pub;
        v->__copyFrom(proxy);
    }
}

void
IceProxy::Robot::Pub::Notify(const ::std::string& __p_strType, const ::std::string& __p_msg, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Pub__Notify_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strType);
        __os->write(__p_msg);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Pub::begin_Notify(const ::std::string& __p_strType, const ::std::string& __p_msg, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Pub__Notify_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Pub__Notify_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_strType);
        __os->write(__p_msg);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Pub::end_Notify(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Pub__Notify_name);
}

const ::std::string&
IceProxy::Robot::Pub::ice_staticId()
{
    return ::Robot::Pub::ice_staticId();
}

::IceProxy::Ice::Object*
IceProxy::Robot::Pub::__newInstance() const
{
    return new Pub;
}
::IceProxy::Ice::Object* ::IceProxy::Robot::upCast(::IceProxy::Robot::Session* p) { return p; }

void
::IceProxy::Robot::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Session>& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Robot::Session;
        v->__copyFrom(proxy);
    }
}

void
IceProxy::Robot::Session::List(::Ice::StringSeq& __p_sList, const ::Ice::Context* __ctx)
{
    __checkTwowayOnly(__Robot__Session__List_name);
    ::IceInternal::Outgoing __og(this, __Robot__Session__List_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    if(!__og.invoke())
    {
        try
        {
            __og.throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
            throw __uue;
        }
    }
    ::IceInternal::BasicStream* __is = __og.startReadParams();
    __is->read(__p_sList);
    __og.endReadParams();
}

::Ice::AsyncResultPtr
IceProxy::Robot::Session::begin_List(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    __checkAsyncTwowayOnly(__Robot__Session__List_name);
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Session__List_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Session__List_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

#ifdef ICE_CPP11

::Ice::AsyncResultPtr
IceProxy::Robot::Session::__begin_List(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::StringSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent)
{
    class Cpp11CB : public ::IceInternal::Cpp11FnCallbackNC
    {
    public:

        Cpp11CB(const ::std::function<void (const ::Ice::StringSeq&)>& responseFunc, const ::std::function<void (const ::Ice::Exception&)>& exceptionFunc, const ::std::function<void (bool)>& sentFunc) :
            ::IceInternal::Cpp11FnCallbackNC(exceptionFunc, sentFunc),
            _response(responseFunc)
        {
            CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
        }

        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
        {
            ::Robot::SessionPrx __proxy = ::Robot::SessionPrx::uncheckedCast(__result->getProxy());
            ::Ice::StringSeq __p_sList;
            try
            {
                __proxy->end_List(__p_sList, __result);
            }
            catch(const ::Ice::Exception& ex)
            {
                Cpp11FnCallbackNC::exception(__result, ex);
                return;
            }
            if(_response != nullptr)
            {
                _response(__p_sList);
            }
        }

    private:

        ::std::function<void (const ::Ice::StringSeq&)> _response;
    };
    return begin_List(__ctx, new Cpp11CB(__response, __exception, __sent));
}
#endif

void
IceProxy::Robot::Session::end_List(::Ice::StringSeq& __p_sList, const ::Ice::AsyncResultPtr& __result)
{
    ::Ice::AsyncResult::__check(__result, this, __Robot__Session__List_name);
    if(!__result->__wait())
    {
        try
        {
            __result->__throwUserException();
        }
        catch(const ::Ice::UserException& __ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
        }
    }
    ::IceInternal::BasicStream* __is = __result->__startReadParams();
    __is->read(__p_sList);
    __result->__endReadParams();
}

const ::std::string&
IceProxy::Robot::Session::ice_staticId()
{
    return ::Robot::Session::ice_staticId();
}

::IceProxy::Ice::Object*
IceProxy::Robot::Session::__newInstance() const
{
    return new Session;
}
::IceProxy::Ice::Object* ::IceProxy::Robot::upCast(::IceProxy::Robot::Live* p) { return p; }

void
::IceProxy::Robot::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Live>& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Robot::Live;
        v->__copyFrom(proxy);
    }
}

void
IceProxy::Robot::Live::RemoteRecvStart(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Live__RemoteRecvStart_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Live::begin_RemoteRecvStart(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Live__RemoteRecvStart_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Live__RemoteRecvStart_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Live::end_RemoteRecvStart(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Live__RemoteRecvStart_name);
}

void
IceProxy::Robot::Live::RemoteRecvStop(const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Robot__Live__RemoteRecvStop_name, ::Ice::Normal, __ctx);
    __og.writeEmptyParams();
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Robot::Live::begin_RemoteRecvStop(const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Robot__Live__RemoteRecvStop_name, __del, __cookie);
    try
    {
        __result->prepare(__Robot__Live__RemoteRecvStop_name, ::Ice::Normal, __ctx);
        __result->writeEmptyParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Robot::Live::end_RemoteRecvStop(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Robot__Live__RemoteRecvStop_name);
}

const ::std::string&
IceProxy::Robot::Live::ice_staticId()
{
    return ::Robot::Live::ice_staticId();
}

::IceProxy::Ice::Object*
IceProxy::Robot::Live::__newInstance() const
{
    return new Live;
}

::Ice::Object* Robot::upCast(::Robot::Json* p) { return p; }

namespace
{
const ::std::string __Robot__Json_ids[2] =
{
    "::Ice::Object",
    "::Robot::Json"
};

}

bool
Robot::Json::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Robot__Json_ids, __Robot__Json_ids + 2, _s);
}

::std::vector< ::std::string>
Robot::Json::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Robot__Json_ids[0], &__Robot__Json_ids[2]);
}

const ::std::string&
Robot::Json::ice_id(const ::Ice::Current&) const
{
    return __Robot__Json_ids[1];
}

const ::std::string&
Robot::Json::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::Robot::Json";
    return typeId;
#else
    return __Robot__Json_ids[1];
#endif
}

::Ice::DispatchStatus
Robot::Json::___Load(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::std::string __p_strPath;
    __is->read(__p_strPath);
    __inS.endReadParams();
    bool __ret = Load(__p_strPath, __current);
    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
    __os->write(__ret);
    __inS.__endWriteParams(true);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Json::___CallByName(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::std::string __p_strName;
    __is->read(__p_strName);
    __inS.endReadParams();
    CallByName(__p_strName, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Json::___CallByClass(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::std::string __p_strClassName;
    __is->read(__p_strClassName);
    __inS.endReadParams();
    CallByClass(__p_strClassName, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Json::___CallByContent(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::std::string __p_strBase64;
    __is->read(__p_strBase64);
    __inS.endReadParams();
    CallByContent(__p_strBase64, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Json::___Stop(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    Stop(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Json::___IsPlaying(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    bool __ret = IsPlaying(__current);
    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
    __os->write(__ret);
    __inS.__endWriteParams(true);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Json::___List(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    ::Ice::StringSeq __p_strList;
    List(__p_strList, __current);
    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
    __os->write(__p_strList);
    __inS.__endWriteParams(true);
    return ::Ice::DispatchOK;
}

namespace
{
const ::std::string __Robot__Json_all[] =
{
    "CallByClass",
    "CallByContent",
    "CallByName",
    "IsPlaying",
    "List",
    "Load",
    "Stop",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

}

::Ice::DispatchStatus
Robot::Json::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Robot__Json_all, __Robot__Json_all + 11, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Robot__Json_all)
    {
        case 0:
        {
            return ___CallByClass(in, current);
        }
        case 1:
        {
            return ___CallByContent(in, current);
        }
        case 2:
        {
            return ___CallByName(in, current);
        }
        case 3:
        {
            return ___IsPlaying(in, current);
        }
        case 4:
        {
            return ___List(in, current);
        }
        case 5:
        {
            return ___Load(in, current);
        }
        case 6:
        {
            return ___Stop(in, current);
        }
        case 7:
        {
            return ___ice_id(in, current);
        }
        case 8:
        {
            return ___ice_ids(in, current);
        }
        case 9:
        {
            return ___ice_isA(in, current);
        }
        case 10:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Robot::Json::__writeImpl(::IceInternal::BasicStream* __os) const
{
    __os->startWriteSlice(ice_staticId(), -1, true);
    __os->endWriteSlice();
}

void
Robot::Json::__readImpl(::IceInternal::BasicStream* __is)
{
    __is->startReadSlice();
    __is->endReadSlice();
}

void
Robot::__patch(JsonPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ::Robot::JsonPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(::Robot::Json::ice_staticId(), v);
    }
}

::Ice::Object* Robot::upCast(::Robot::Motor* p) { return p; }

namespace
{
const ::std::string __Robot__Motor_ids[2] =
{
    "::Ice::Object",
    "::Robot::Motor"
};

}

bool
Robot::Motor::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Robot__Motor_ids, __Robot__Motor_ids + 2, _s);
}

::std::vector< ::std::string>
Robot::Motor::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Robot__Motor_ids[0], &__Robot__Motor_ids[2]);
}

const ::std::string&
Robot::Motor::ice_id(const ::Ice::Current&) const
{
    return __Robot__Motor_ids[1];
}

const ::std::string&
Robot::Motor::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::Robot::Motor";
    return typeId;
#else
    return __Robot__Motor_ids[1];
#endif
}

::Ice::DispatchStatus
Robot::Motor::___SerialWrite(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::ByteSeq __p_bHexData;
    __is->read(__p_bHexData);
    __inS.endReadParams();
    SerialWrite(__p_bHexData, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HeadEnable(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    bool __p_bLR;
    bool __p_bUD;
    __is->read(__p_bLR);
    __is->read(__p_bUD);
    __inS.endReadParams();
    HeadEnable(__p_bLR, __p_bUD, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HeadLrInit(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    HeadLrInit(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HeadUdInit(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    HeadUdInit(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HeadLrAngle(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nAngle;
    ::Ice::Int __p_nSpeed;
    __is->read(__p_nAngle);
    __is->read(__p_nSpeed);
    __inS.endReadParams();
    HeadLrAngle(__p_nAngle, __p_nSpeed, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HeadUdAngle(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nAngle;
    ::Ice::Int __p_nSpeed;
    __is->read(__p_nAngle);
    __is->read(__p_nSpeed);
    __inS.endReadParams();
    HeadUdAngle(__p_nAngle, __p_nSpeed, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HandLEnable(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    bool __p_bSwing;
    bool __p_bExpand;
    __is->read(__p_bSwing);
    __is->read(__p_bExpand);
    __inS.endReadParams();
    HandLEnable(__p_bSwing, __p_bExpand, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HandLSwingInit(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    HandLSwingInit(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HandLExpandInit(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    HandLExpandInit(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HandLSwingAngle(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nAngle;
    ::Ice::Int __p_nSpeed;
    __is->read(__p_nAngle);
    __is->read(__p_nSpeed);
    __inS.endReadParams();
    HandLSwingAngle(__p_nAngle, __p_nSpeed, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HandLExpandAngle(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nAngle;
    ::Ice::Int __p_nSpeed;
    __is->read(__p_nAngle);
    __is->read(__p_nSpeed);
    __inS.endReadParams();
    HandLExpandAngle(__p_nAngle, __p_nSpeed, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HandREnable(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    bool __p_bSwing;
    bool __p_bExpand;
    __is->read(__p_bSwing);
    __is->read(__p_bExpand);
    __inS.endReadParams();
    HandREnable(__p_bSwing, __p_bExpand, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HandRSwingInit(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    HandRSwingInit(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HandRExpandInit(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    HandRExpandInit(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HandRSwingAngle(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nAngle;
    ::Ice::Int __p_nSpeed;
    __is->read(__p_nAngle);
    __is->read(__p_nSpeed);
    __inS.endReadParams();
    HandRSwingAngle(__p_nAngle, __p_nSpeed, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HandRExpandAngle(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nAngle;
    ::Ice::Int __p_nSpeed;
    __is->read(__p_nAngle);
    __is->read(__p_nSpeed);
    __inS.endReadParams();
    HandRExpandAngle(__p_nAngle, __p_nSpeed, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___WheelEnable(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    bool __p_bEnable;
    __is->read(__p_bEnable);
    __inS.endReadParams();
    WheelEnable(__p_bEnable, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___WheelStop(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    bool __p_bSlow;
    __is->read(__p_bSlow);
    __inS.endReadParams();
    WheelStop(__p_bSlow, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___WheelRotate(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nAngle;
    ::Ice::Int __p_nSpeed;
    __is->read(__p_nAngle);
    __is->read(__p_nSpeed);
    __inS.endReadParams();
    WheelRotate(__p_nAngle, __p_nSpeed, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___WheelRun(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nDistance;
    ::Ice::Int __p_nSpeed;
    __is->read(__p_nDistance);
    __is->read(__p_nSpeed);
    __inS.endReadParams();
    WheelRun(__p_nDistance, __p_nSpeed, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___WheelRunDiff(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    bool __p_bLeftUP;
    ::Ice::Int __p_nLeftSpeed;
    bool __p_bRight;
    ::Ice::Int __p_nRightSpeed;
    __is->read(__p_bLeftUP);
    __is->read(__p_nLeftSpeed);
    __is->read(__p_bRight);
    __is->read(__p_nRightSpeed);
    __inS.endReadParams();
    WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HeadEye(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nIndexF;
    ::Ice::Int __p_nIndexB;
    __is->read(__p_nIndexF);
    __is->read(__p_nIndexB);
    __inS.endReadParams();
    HeadEye(__p_nIndexF, __p_nIndexB, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HeadEye2(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nDelay;
    bool __p_bR;
    bool __p_bG;
    bool __p_bB;
    __is->read(__p_nDelay);
    __is->read(__p_bR);
    __is->read(__p_bG);
    __is->read(__p_bB);
    __inS.endReadParams();
    HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___HeadEar(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nDelay;
    bool __p_bR;
    bool __p_bG;
    bool __p_bB;
    __is->read(__p_nDelay);
    __is->read(__p_bR);
    __is->read(__p_bG);
    __is->read(__p_bB);
    __inS.endReadParams();
    HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___BodyLed(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nDelay;
    bool __p_bR;
    bool __p_bG;
    bool __p_bB;
    __is->read(__p_nDelay);
    __is->read(__p_bR);
    __is->read(__p_bG);
    __is->read(__p_bB);
    __inS.endReadParams();
    BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___TouchSet(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    bool __p_bFlash;
    ::Ice::Int __p_nColor;
    ::Ice::Int __p_nDelay;
    __is->read(__p_bFlash);
    __is->read(__p_nColor);
    __is->read(__p_nDelay);
    __inS.endReadParams();
    TouchSet(__p_bFlash, __p_nColor, __p_nDelay, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___SensorBatteryValue(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    ::Ice::IntSeq __p_nValList;
    SensorBatteryValue(__p_nValList, __current);
    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
    __os->write(__p_nValList);
    __inS.__endWriteParams(true);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___SensorSonicValue(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    ::Ice::IntSeq __p_nValList;
    SensorSonicValue(__p_nValList, __current);
    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
    __os->write(__p_nValList);
    __inS.__endWriteParams(true);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___SensorInfraredValue(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    ::Ice::IntSeq __p_nValList;
    SensorInfraredValue(__p_nValList, __current);
    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
    __os->write(__p_nValList);
    __inS.__endWriteParams(true);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___SetProtect(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    bool __p_bOpen;
    __is->read(__p_bOpen);
    __inS.endReadParams();
    SetProtect(__p_bOpen, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Motor::___GetProtect(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    bool __ret = GetProtect(__current);
    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
    __os->write(__ret);
    __inS.__endWriteParams(true);
    return ::Ice::DispatchOK;
}

namespace
{
const ::std::string __Robot__Motor_all[] =
{
    "BodyLed",
    "GetProtect",
    "HandLEnable",
    "HandLExpandAngle",
    "HandLExpandInit",
    "HandLSwingAngle",
    "HandLSwingInit",
    "HandREnable",
    "HandRExpandAngle",
    "HandRExpandInit",
    "HandRSwingAngle",
    "HandRSwingInit",
    "HeadEar",
    "HeadEnable",
    "HeadEye",
    "HeadEye2",
    "HeadLrAngle",
    "HeadLrInit",
    "HeadUdAngle",
    "HeadUdInit",
    "SensorBatteryValue",
    "SensorInfraredValue",
    "SensorSonicValue",
    "SerialWrite",
    "SetProtect",
    "TouchSet",
    "WheelEnable",
    "WheelRotate",
    "WheelRun",
    "WheelRunDiff",
    "WheelStop",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

}

::Ice::DispatchStatus
Robot::Motor::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Robot__Motor_all, __Robot__Motor_all + 35, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Robot__Motor_all)
    {
        case 0:
        {
            return ___BodyLed(in, current);
        }
        case 1:
        {
            return ___GetProtect(in, current);
        }
        case 2:
        {
            return ___HandLEnable(in, current);
        }
        case 3:
        {
            return ___HandLExpandAngle(in, current);
        }
        case 4:
        {
            return ___HandLExpandInit(in, current);
        }
        case 5:
        {
            return ___HandLSwingAngle(in, current);
        }
        case 6:
        {
            return ___HandLSwingInit(in, current);
        }
        case 7:
        {
            return ___HandREnable(in, current);
        }
        case 8:
        {
            return ___HandRExpandAngle(in, current);
        }
        case 9:
        {
            return ___HandRExpandInit(in, current);
        }
        case 10:
        {
            return ___HandRSwingAngle(in, current);
        }
        case 11:
        {
            return ___HandRSwingInit(in, current);
        }
        case 12:
        {
            return ___HeadEar(in, current);
        }
        case 13:
        {
            return ___HeadEnable(in, current);
        }
        case 14:
        {
            return ___HeadEye(in, current);
        }
        case 15:
        {
            return ___HeadEye2(in, current);
        }
        case 16:
        {
            return ___HeadLrAngle(in, current);
        }
        case 17:
        {
            return ___HeadLrInit(in, current);
        }
        case 18:
        {
            return ___HeadUdAngle(in, current);
        }
        case 19:
        {
            return ___HeadUdInit(in, current);
        }
        case 20:
        {
            return ___SensorBatteryValue(in, current);
        }
        case 21:
        {
            return ___SensorInfraredValue(in, current);
        }
        case 22:
        {
            return ___SensorSonicValue(in, current);
        }
        case 23:
        {
            return ___SerialWrite(in, current);
        }
        case 24:
        {
            return ___SetProtect(in, current);
        }
        case 25:
        {
            return ___TouchSet(in, current);
        }
        case 26:
        {
            return ___WheelEnable(in, current);
        }
        case 27:
        {
            return ___WheelRotate(in, current);
        }
        case 28:
        {
            return ___WheelRun(in, current);
        }
        case 29:
        {
            return ___WheelRunDiff(in, current);
        }
        case 30:
        {
            return ___WheelStop(in, current);
        }
        case 31:
        {
            return ___ice_id(in, current);
        }
        case 32:
        {
            return ___ice_ids(in, current);
        }
        case 33:
        {
            return ___ice_isA(in, current);
        }
        case 34:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Robot::Motor::__writeImpl(::IceInternal::BasicStream* __os) const
{
    __os->startWriteSlice(ice_staticId(), -1, true);
    __os->endWriteSlice();
}

void
Robot::Motor::__readImpl(::IceInternal::BasicStream* __is)
{
    __is->startReadSlice();
    __is->endReadSlice();
}

void
Robot::__patch(MotorPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ::Robot::MotorPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(::Robot::Motor::ice_staticId(), v);
    }
}

::Ice::Object* Robot::upCast(::Robot::Audio* p) { return p; }

namespace
{
const ::std::string __Robot__Audio_ids[2] =
{
    "::Ice::Object",
    "::Robot::Audio"
};

}

bool
Robot::Audio::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Robot__Audio_ids, __Robot__Audio_ids + 2, _s);
}

::std::vector< ::std::string>
Robot::Audio::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Robot__Audio_ids[0], &__Robot__Audio_ids[2]);
}

const ::std::string&
Robot::Audio::ice_id(const ::Ice::Current&) const
{
    return __Robot__Audio_ids[1];
}

const ::std::string&
Robot::Audio::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::Robot::Audio";
    return typeId;
#else
    return __Robot__Audio_ids[1];
#endif
}

::Ice::DispatchStatus
Robot::Audio::___TtsPlayParams(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::std::string __p_strTxt;
    ::std::string __p_strSpeaker;
    ::Ice::Int __p_nSpeed;
    ::Ice::Int __p_nPitch;
    __is->read(__p_strTxt);
    __is->read(__p_strSpeaker);
    __is->read(__p_nSpeed);
    __is->read(__p_nPitch);
    __inS.endReadParams();
    TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Audio::___TtsPlay(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::std::string __p_strTxt;
    __is->read(__p_strTxt);
    __inS.endReadParams();
    TtsPlay(__p_strTxt, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Audio::___TtsPlayFile(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::std::string __p_strPath;
    __is->read(__p_strPath);
    __inS.endReadParams();
    TtsPlayFile(__p_strPath, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Audio::___TtsSetVolume(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nVal;
    __is->read(__p_nVal);
    __inS.endReadParams();
    TtsSetVolume(__p_nVal, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Audio::___TtsStop(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    TtsStop(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Audio::___TtsIsPlaying(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    bool __ret = TtsIsPlaying(__current);
    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
    __os->write(__ret);
    __inS.__endWriteParams(true);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Audio::___AsrBuildCmd(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::StringSeq __p_strCmdList;
    __is->read(__p_strCmdList);
    __inS.endReadParams();
    AsrBuildCmd(__p_strCmdList, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Audio::___AsrStart(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nMaxDelayMs;
    __is->read(__p_nMaxDelayMs);
    __inS.endReadParams();
    AsrStart(__p_nMaxDelayMs, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Audio::___AsrStop(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    AsrStop(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Audio::___MediaPlay(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::std::string __p_strPath;
    __is->read(__p_strPath);
    __inS.endReadParams();
    MediaPlay(__p_strPath, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Audio::___MediaSetVolume(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nVal;
    __is->read(__p_nVal);
    __inS.endReadParams();
    MediaSetVolume(__p_nVal, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Audio::___MediaStop(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    MediaStop(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Audio::___MediaIsPlaying(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    bool __ret = MediaIsPlaying(__current);
    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
    __os->write(__ret);
    __inS.__endWriteParams(true);
    return ::Ice::DispatchOK;
}

namespace
{
const ::std::string __Robot__Audio_all[] =
{
    "AsrBuildCmd",
    "AsrStart",
    "AsrStop",
    "MediaIsPlaying",
    "MediaPlay",
    "MediaSetVolume",
    "MediaStop",
    "TtsIsPlaying",
    "TtsPlay",
    "TtsPlayFile",
    "TtsPlayParams",
    "TtsSetVolume",
    "TtsStop",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

}

::Ice::DispatchStatus
Robot::Audio::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Robot__Audio_all, __Robot__Audio_all + 17, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Robot__Audio_all)
    {
        case 0:
        {
            return ___AsrBuildCmd(in, current);
        }
        case 1:
        {
            return ___AsrStart(in, current);
        }
        case 2:
        {
            return ___AsrStop(in, current);
        }
        case 3:
        {
            return ___MediaIsPlaying(in, current);
        }
        case 4:
        {
            return ___MediaPlay(in, current);
        }
        case 5:
        {
            return ___MediaSetVolume(in, current);
        }
        case 6:
        {
            return ___MediaStop(in, current);
        }
        case 7:
        {
            return ___TtsIsPlaying(in, current);
        }
        case 8:
        {
            return ___TtsPlay(in, current);
        }
        case 9:
        {
            return ___TtsPlayFile(in, current);
        }
        case 10:
        {
            return ___TtsPlayParams(in, current);
        }
        case 11:
        {
            return ___TtsSetVolume(in, current);
        }
        case 12:
        {
            return ___TtsStop(in, current);
        }
        case 13:
        {
            return ___ice_id(in, current);
        }
        case 14:
        {
            return ___ice_ids(in, current);
        }
        case 15:
        {
            return ___ice_isA(in, current);
        }
        case 16:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Robot::Audio::__writeImpl(::IceInternal::BasicStream* __os) const
{
    __os->startWriteSlice(ice_staticId(), -1, true);
    __os->endWriteSlice();
}

void
Robot::Audio::__readImpl(::IceInternal::BasicStream* __is)
{
    __is->startReadSlice();
    __is->endReadSlice();
}

void
Robot::__patch(AudioPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ::Robot::AudioPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(::Robot::Audio::ice_staticId(), v);
    }
}

::Ice::Object* Robot::upCast(::Robot::ScreenEx* p) { return p; }

namespace
{
const ::std::string __Robot__ScreenEx_ids[2] =
{
    "::Ice::Object",
    "::Robot::ScreenEx"
};

}

bool
Robot::ScreenEx::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Robot__ScreenEx_ids, __Robot__ScreenEx_ids + 2, _s);
}

::std::vector< ::std::string>
Robot::ScreenEx::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Robot__ScreenEx_ids[0], &__Robot__ScreenEx_ids[2]);
}

const ::std::string&
Robot::ScreenEx::ice_id(const ::Ice::Current&) const
{
    return __Robot__ScreenEx_ids[1];
}

const ::std::string&
Robot::ScreenEx::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::Robot::ScreenEx";
    return typeId;
#else
    return __Robot__ScreenEx_ids[1];
#endif
}

::Ice::DispatchStatus
Robot::ScreenEx::___ShowRepeatDir(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nDelay;
    ::std::string __p_strDir;
    __is->read(__p_nDelay);
    __is->read(__p_strDir);
    __inS.endReadParams();
    ShowRepeatDir(__p_nDelay, __p_strDir, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::ScreenEx::___ShowPic(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nDelay;
    ::std::string __p_strPath;
    __is->read(__p_nDelay);
    __is->read(__p_strPath);
    __inS.endReadParams();
    ShowPic(__p_nDelay, __p_strPath, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::ScreenEx::___ShowVideo(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nDelay;
    ::std::string __p_strPath;
    __is->read(__p_nDelay);
    __is->read(__p_strPath);
    __inS.endReadParams();
    ShowVideo(__p_nDelay, __p_strPath, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::ScreenEx::___Clean(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    Clean(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::ScreenEx::___ShowVip(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::std::string __p_strName;
    ::std::string __p_strImg;
    __is->read(__p_strName);
    __is->read(__p_strImg);
    __inS.endReadParams();
    ShowVip(__p_strName, __p_strImg, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::ScreenEx::___ShowBarrage(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nDelay;
    ::std::string __p_strTxt;
    __is->read(__p_nDelay);
    __is->read(__p_strTxt);
    __inS.endReadParams();
    ShowBarrage(__p_nDelay, __p_strTxt, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

namespace
{
const ::std::string __Robot__ScreenEx_all[] =
{
    "Clean",
    "ShowBarrage",
    "ShowPic",
    "ShowRepeatDir",
    "ShowVideo",
    "ShowVip",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

}

::Ice::DispatchStatus
Robot::ScreenEx::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Robot__ScreenEx_all, __Robot__ScreenEx_all + 10, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Robot__ScreenEx_all)
    {
        case 0:
        {
            return ___Clean(in, current);
        }
        case 1:
        {
            return ___ShowBarrage(in, current);
        }
        case 2:
        {
            return ___ShowPic(in, current);
        }
        case 3:
        {
            return ___ShowRepeatDir(in, current);
        }
        case 4:
        {
            return ___ShowVideo(in, current);
        }
        case 5:
        {
            return ___ShowVip(in, current);
        }
        case 6:
        {
            return ___ice_id(in, current);
        }
        case 7:
        {
            return ___ice_ids(in, current);
        }
        case 8:
        {
            return ___ice_isA(in, current);
        }
        case 9:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Robot::ScreenEx::__writeImpl(::IceInternal::BasicStream* __os) const
{
    __os->startWriteSlice(ice_staticId(), -1, true);
    __os->endWriteSlice();
}

void
Robot::ScreenEx::__readImpl(::IceInternal::BasicStream* __is)
{
    __is->startReadSlice();
    __is->endReadSlice();
}

void
Robot::__patch(ScreenExPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ::Robot::ScreenExPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(::Robot::ScreenEx::ice_staticId(), v);
    }
}

::Ice::Object* Robot::upCast(::Robot::Config* p) { return p; }

namespace
{
const ::std::string __Robot__Config_ids[2] =
{
    "::Ice::Object",
    "::Robot::Config"
};

}

bool
Robot::Config::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Robot__Config_ids, __Robot__Config_ids + 2, _s);
}

::std::vector< ::std::string>
Robot::Config::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Robot__Config_ids[0], &__Robot__Config_ids[2]);
}

const ::std::string&
Robot::Config::ice_id(const ::Ice::Current&) const
{
    return __Robot__Config_ids[1];
}

const ::std::string&
Robot::Config::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::Robot::Config";
    return typeId;
#else
    return __Robot__Config_ids[1];
#endif
}

::Ice::DispatchStatus
Robot::Config::___SetSystemVolume(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_nVal;
    __is->read(__p_nVal);
    __inS.endReadParams();
    SetSystemVolume(__p_nVal, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Config::___GetSystemVolume(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    ::Ice::Int __ret = GetSystemVolume(__current);
    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
    __os->write(__ret);
    __inS.__endWriteParams(true);
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Config::___SetSystemCmd(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::std::string __p_strCmd;
    __is->read(__p_strCmd);
    __inS.endReadParams();
    SetSystemCmd(__p_strCmd, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

namespace
{
const ::std::string __Robot__Config_all[] =
{
    "GetSystemVolume",
    "SetSystemCmd",
    "SetSystemVolume",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

}

::Ice::DispatchStatus
Robot::Config::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Robot__Config_all, __Robot__Config_all + 7, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Robot__Config_all)
    {
        case 0:
        {
            return ___GetSystemVolume(in, current);
        }
        case 1:
        {
            return ___SetSystemCmd(in, current);
        }
        case 2:
        {
            return ___SetSystemVolume(in, current);
        }
        case 3:
        {
            return ___ice_id(in, current);
        }
        case 4:
        {
            return ___ice_ids(in, current);
        }
        case 5:
        {
            return ___ice_isA(in, current);
        }
        case 6:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Robot::Config::__writeImpl(::IceInternal::BasicStream* __os) const
{
    __os->startWriteSlice(ice_staticId(), -1, true);
    __os->endWriteSlice();
}

void
Robot::Config::__readImpl(::IceInternal::BasicStream* __is)
{
    __is->startReadSlice();
    __is->endReadSlice();
}

void
Robot::__patch(ConfigPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ::Robot::ConfigPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(::Robot::Config::ice_staticId(), v);
    }
}

::Ice::Object* Robot::upCast(::Robot::Pub* p) { return p; }

namespace
{
const ::std::string __Robot__Pub_ids[2] =
{
    "::Ice::Object",
    "::Robot::Pub"
};

}

bool
Robot::Pub::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Robot__Pub_ids, __Robot__Pub_ids + 2, _s);
}

::std::vector< ::std::string>
Robot::Pub::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Robot__Pub_ids[0], &__Robot__Pub_ids[2]);
}

const ::std::string&
Robot::Pub::ice_id(const ::Ice::Current&) const
{
    return __Robot__Pub_ids[1];
}

const ::std::string&
Robot::Pub::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::Robot::Pub";
    return typeId;
#else
    return __Robot__Pub_ids[1];
#endif
}

::Ice::DispatchStatus
Robot::Pub::___Notify(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::std::string __p_strType;
    ::std::string __p_msg;
    __is->read(__p_strType);
    __is->read(__p_msg);
    __inS.endReadParams();
    Notify(__p_strType, __p_msg, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

namespace
{
const ::std::string __Robot__Pub_all[] =
{
    "Notify",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

}

::Ice::DispatchStatus
Robot::Pub::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Robot__Pub_all, __Robot__Pub_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Robot__Pub_all)
    {
        case 0:
        {
            return ___Notify(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Robot::Pub::__writeImpl(::IceInternal::BasicStream* __os) const
{
    __os->startWriteSlice(ice_staticId(), -1, true);
    __os->endWriteSlice();
}

void
Robot::Pub::__readImpl(::IceInternal::BasicStream* __is)
{
    __is->startReadSlice();
    __is->endReadSlice();
}

void
Robot::__patch(PubPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ::Robot::PubPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(::Robot::Pub::ice_staticId(), v);
    }
}

::Ice::Object* Robot::upCast(::Robot::Session* p) { return p; }

namespace
{
const ::std::string __Robot__Session_ids[2] =
{
    "::Ice::Object",
    "::Robot::Session"
};

}

bool
Robot::Session::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Robot__Session_ids, __Robot__Session_ids + 2, _s);
}

::std::vector< ::std::string>
Robot::Session::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Robot__Session_ids[0], &__Robot__Session_ids[2]);
}

const ::std::string&
Robot::Session::ice_id(const ::Ice::Current&) const
{
    return __Robot__Session_ids[1];
}

const ::std::string&
Robot::Session::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::Robot::Session";
    return typeId;
#else
    return __Robot__Session_ids[1];
#endif
}

::Ice::DispatchStatus
Robot::Session::___List(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    ::Ice::StringSeq __p_sList;
    List(__p_sList, __current);
    ::IceInternal::BasicStream* __os = __inS.__startWriteParams(::Ice::DefaultFormat);
    __os->write(__p_sList);
    __inS.__endWriteParams(true);
    return ::Ice::DispatchOK;
}

namespace
{
const ::std::string __Robot__Session_all[] =
{
    "List",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

}

::Ice::DispatchStatus
Robot::Session::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Robot__Session_all, __Robot__Session_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Robot__Session_all)
    {
        case 0:
        {
            return ___List(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Robot::Session::__writeImpl(::IceInternal::BasicStream* __os) const
{
    __os->startWriteSlice(ice_staticId(), -1, true);
    __os->endWriteSlice();
}

void
Robot::Session::__readImpl(::IceInternal::BasicStream* __is)
{
    __is->startReadSlice();
    __is->endReadSlice();
}

void
Robot::__patch(SessionPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ::Robot::SessionPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(::Robot::Session::ice_staticId(), v);
    }
}

::Ice::Object* Robot::upCast(::Robot::Live* p) { return p; }

namespace
{
const ::std::string __Robot__Live_ids[2] =
{
    "::Ice::Object",
    "::Robot::Live"
};

}

bool
Robot::Live::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Robot__Live_ids, __Robot__Live_ids + 2, _s);
}

::std::vector< ::std::string>
Robot::Live::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Robot__Live_ids[0], &__Robot__Live_ids[2]);
}

const ::std::string&
Robot::Live::ice_id(const ::Ice::Current&) const
{
    return __Robot__Live_ids[1];
}

const ::std::string&
Robot::Live::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::Robot::Live";
    return typeId;
#else
    return __Robot__Live_ids[1];
#endif
}

::Ice::DispatchStatus
Robot::Live::___RemoteRecvStart(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    RemoteRecvStart(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

::Ice::DispatchStatus
Robot::Live::___RemoteRecvStop(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    __inS.readEmptyParams();
    RemoteRecvStop(__current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

namespace
{
const ::std::string __Robot__Live_all[] =
{
    "RemoteRecvStart",
    "RemoteRecvStop",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

}

::Ice::DispatchStatus
Robot::Live::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Robot__Live_all, __Robot__Live_all + 6, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Robot__Live_all)
    {
        case 0:
        {
            return ___RemoteRecvStart(in, current);
        }
        case 1:
        {
            return ___RemoteRecvStop(in, current);
        }
        case 2:
        {
            return ___ice_id(in, current);
        }
        case 3:
        {
            return ___ice_ids(in, current);
        }
        case 4:
        {
            return ___ice_isA(in, current);
        }
        case 5:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Robot::Live::__writeImpl(::IceInternal::BasicStream* __os) const
{
    __os->startWriteSlice(ice_staticId(), -1, true);
    __os->endWriteSlice();
}

void
Robot::Live::__readImpl(::IceInternal::BasicStream* __is)
{
    __is->startReadSlice();
    __is->endReadSlice();
}

void
Robot::__patch(LivePtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ::Robot::LivePtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(::Robot::Live::ice_staticId(), v);
    }
}

